package com.stedu.mall.goodsservice.serice;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.stedu.mall.common.bean.Category;
import com.stedu.mall.common.exception.SteduException;
import com.stedu.mall.common.service.CategoryService;
import com.stedu.mall.goodsservice.mapper.CategoryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class CategoryServiceImpl implements CategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insert(Category category) throws SteduException {
        /*
         * 判断被添加分类的父分类是否存在
         * 1.根据被添加分类的parentId查询其父分类
         * 2.判断这个父分类是否是真的父分类
         * */
        if (!category.getParentId().equals(0)) {//确保添加的类不是父类
            Category parent = categoryMapper.selectById(category.getParentId());
            //父类不存在或者父类存在但是父类的parentId不是0
            if (parent == null || parent != null && !parent.getParentId().equals(0)) {
                throw new SteduException("被添加的分类的父类不存在或者不合法，无法添加");
            } else if (parent.getName().equals(category.getName())) {
                throw new SteduException("添加的分类和其父类的名字相同，无法添加");
            }
        }
        /*
         * 判断同一个父类下是否有同名的子分类
         * 1.查询这个添加的类的父类的下面的所有子类
         * 2.判断是否重名
         * */
        List<Category> categoryList = categoryMapper.selectByParentId(category.getParentId());
        boolean b = categoryList.stream()
                .anyMatch(item -> item.getName().equals(category.getName()));
        if (b) {
            throw new SteduException("添加的分类重复，无法添加");
        }
        return (categoryMapper.insert(category) == 1);
    }

    @Override
    public boolean delete(Integer id) throws SteduException {
        //如果是子类判断存在不存在
        Category category = categoryMapper.selectById(id);
        if (category == null) {
            throw new SteduException("删除的类不存在，无法删除");
        }
        //如果是父类判断子类是否存在
        if (category.getParentId().equals(0) && category.getChildList().size() != 0) {
            throw new SteduException("删除的类下边还有子类，无法删除");
        }
        // TODO: 2024/9/21 如果是子类判断其下有没有商品
        //删除
        return (categoryMapper.delete(id) == 1);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean update(Category category) throws SteduException {
        //查询被修改的类的信息
        Category oldInfo = categoryMapper.selectById(category.getId());//改前
        Category newInfo = category;//改后
        //修改的类是否存在
        if (oldInfo == null) {
            throw new SteduException("被修改的类不存在，无法修改");
        }
        //一个父类不能把自己设置为自己的父类
        if (!oldInfo.getParentId().equals(0)) {
            if (oldInfo.getParentId().equals(0) && !newInfo.getParent().equals(0) && newInfo.getParentId().equals(oldInfo.getId())) {
                throw new SteduException("父类不能是自己的父类，无法修改");
            }
        }
        //如果是个父类，其下也有子类，不能修改为子类
        if (oldInfo.getParentId().equals(0) && !oldInfo.getChildList().isEmpty() && !newInfo.getParentId().equals(0)) {
            throw new SteduException("父类不能修改为子类，无法修改");
        }
        /*
         *如果是子类，判断重名问题
         * 1.查询修改类的父类
         * 2.判断重名
         * */
        //获取修改后的父类id
        //parentId可能改了也可能没改
        Integer parentId = newInfo.getParentId() == null ? oldInfo.getParentId() : newInfo.getParentId();
        //获取修改之后的名字

        //名字可能改了也可能没改
        String name = newInfo.getName() == null ? oldInfo.getName() : newInfo.getName();
        if (categoryMapper.selectByParentId(parentId)
                .stream()
                .anyMatch(item -> item.getName().equals(name) && !item.getId().equals(category.getId()))) {
            throw new SteduException("修改之后的名字与其他子类名字相同，无法修改");
        }
        //if (categoryMapper.selectByParentId(0)
        //        .stream()
        //        .anyMatch(item -> item.getName().equals(name))) {
        //    throw new SteduException("修改之后的名字与所有父类名字中的一个相同，无法修改");
        //}
        //修改
        return (categoryMapper.update(category) == 1);
    }

    /*
     * 分页和不分页场景都可以使用
     * */
    @Override
    public Object selectByCondition(Category condition, Integer pageNum, Integer pageSize) {
        if (pageNum == null) {//不分页
            return categoryMapper.selectByCondition(condition);
        } else {//分页
            //设置分页参数
            PageHelper.startPage(pageNum, pageSize);
            //查询
            List<Category> categories = categoryMapper.selectByCondition(condition);
            //创建分页信息的对象
            PageInfo<Category> pageInfo = new PageInfo<>(categories);
            return pageInfo;
        }
    }

    @Override
    public Category selectById(Integer id) {
        return categoryMapper.selectById(id);
    }

    @Override
    public List<Category> selectByParentId(Integer parentId) {
        return categoryMapper.selectByParentId(parentId);
    }
}
